// Generated from V3.g4 by ANTLR 4.8
import org.antlr.v4.runtime.atn.*;
import org.antlr.v4.runtime.dfa.DFA;
import org.antlr.v4.runtime.*;
import org.antlr.v4.runtime.misc.*;
import org.antlr.v4.runtime.tree.*;
import java.util.List;
import java.util.Iterator;
import java.util.ArrayList;

@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
public class V3Parser extends Parser {
	static { RuntimeMetaData.checkVersion("4.8", RuntimeMetaData.VERSION); }

	protected static final DFA[] _decisionToDFA;
	protected static final PredictionContextCache _sharedContextCache =
		new PredictionContextCache();
	public static final int
		At=1, Band=2, Run=3, Tool_s=4, Unit=5, Is=6, Return=7, Tool=8, When=9, 
		Listen=10, MessageBus=11, Type_sMessage=12, Then=13, ChatTool=14, ChatRoom=15, 
		MsgContent=16, Reciver=17, After=18, Every=19, Year=20, Month=21, Day=22, 
		Hour=23, Minute=24, Second=25, If=26, Operate=27, Repeat=28, Times=29, 
		Set=30, To=31, Allow=32, Ban=33, Week=34, Comma=35, Dot=36, Number=37, 
		Identifier=38, Ws=39, Comment=40;
	public static final int
		RULE_script = 0, RULE_stmt = 1, RULE_simpleStmt = 2, RULE_intenseStmt = 3, 
		RULE_runToolStmt = 4, RULE_notifyStmt = 5, RULE_paramStmt = 6, RULE_place = 7, 
		RULE_listenStmt = 8, RULE_scheduleStmt = 9, RULE_timeAdverbial = 10, RULE_period = 11, 
		RULE_delay = 12, RULE_complexStmt = 13, RULE_ifStmt = 14, RULE_conditionStmt = 15, 
		RULE_loopStmt = 16, RULE_setStmt = 17, RULE_value = 18, RULE_authoriseStmt = 19, 
		RULE_timeFrame = 20;
	private static String[] makeRuleNames() {
		return new String[] {
			"script", "stmt", "simpleStmt", "intenseStmt", "runToolStmt", "notifyStmt", 
			"paramStmt", "place", "listenStmt", "scheduleStmt", "timeAdverbial", 
			"period", "delay", "complexStmt", "ifStmt", "conditionStmt", "loopStmt", 
			"setStmt", "value", "authoriseStmt", "timeFrame"
		};
	}
	public static final String[] ruleNames = makeRuleNames();

	private static String[] makeLiteralNames() {
		return new String[] {
			null, "'\u5728'", "'\u5E2E\u533A'", null, "'\u5DE5\u5177\u7684'", "'\u90E8\u4EF6'", 
			"'\u4E3A'", "'\u8FD4\u56DE\u7ED3\u679C\u4E3A'", "'\u5DE5\u5177'", "'\u5F53'", 
			"'\u76D1\u542C\u5230'", "'\u6D88\u606F\u603B\u7EBF'", "'\u6D88\u606F\u7684\u7C7B\u578B'", 
			"'\u5219'", "'\u6D88\u606F\u677F\u5DE5\u5177'", "'\u6D88\u606F\u677F'", 
			"'\u6D88\u606F\u5185\u5BB9'", "'\u63A5\u6536\u8005'", null, "'\u6BCF'", 
			"'\u5E74'", "'\u6708'", null, null, null, "'\u79D2'", "'\u5982\u679C'", 
			null, "'\u91CD\u590D'", "'\u6B21'", "'\u8BBE\u7F6E'", "'\u81F3'", "'\u5141\u8BB8'", 
			"'\u7981\u6B62'", "'\u661F\u671F'"
		};
	}
	private static final String[] _LITERAL_NAMES = makeLiteralNames();
	private static String[] makeSymbolicNames() {
		return new String[] {
			null, "At", "Band", "Run", "Tool_s", "Unit", "Is", "Return", "Tool", 
			"When", "Listen", "MessageBus", "Type_sMessage", "Then", "ChatTool", 
			"ChatRoom", "MsgContent", "Reciver", "After", "Every", "Year", "Month", 
			"Day", "Hour", "Minute", "Second", "If", "Operate", "Repeat", "Times", 
			"Set", "To", "Allow", "Ban", "Week", "Comma", "Dot", "Number", "Identifier", 
			"Ws", "Comment"
		};
	}
	private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames();
	public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);

	/**
	 * @deprecated Use {@link #VOCABULARY} instead.
	 */
	@Deprecated
	public static final String[] tokenNames;
	static {
		tokenNames = new String[_SYMBOLIC_NAMES.length];
		for (int i = 0; i < tokenNames.length; i++) {
			tokenNames[i] = VOCABULARY.getLiteralName(i);
			if (tokenNames[i] == null) {
				tokenNames[i] = VOCABULARY.getSymbolicName(i);
			}

			if (tokenNames[i] == null) {
				tokenNames[i] = "<INVALID>";
			}
		}
	}

	@Override
	@Deprecated
	public String[] getTokenNames() {
		return tokenNames;
	}

	@Override

	public Vocabulary getVocabulary() {
		return VOCABULARY;
	}

	@Override
	public String getGrammarFileName() { return "V3.g4"; }

	@Override
	public String[] getRuleNames() { return ruleNames; }

	@Override
	public String getSerializedATN() { return _serializedATN; }

	@Override
	public ATN getATN() { return _ATN; }

	public V3Parser(TokenStream input) {
		super(input);
		_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
	}

	public static class ScriptContext extends ParserRuleContext {
		public List<StmtContext> stmt() {
			return getRuleContexts(StmtContext.class);
		}
		public StmtContext stmt(int i) {
			return getRuleContext(StmtContext.class,i);
		}
		public ScriptContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_script; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof V3Visitor ) return ((V3Visitor<? extends T>)visitor).visitScript(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ScriptContext script() throws RecognitionException {
		ScriptContext _localctx = new ScriptContext(_ctx, getState());
		enterRule(_localctx, 0, RULE_script);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(43); 
			_errHandler.sync(this);
			_la = _input.LA(1);
			do {
				{
				{
				setState(42);
				stmt();
				}
				}
				setState(45); 
				_errHandler.sync(this);
				_la = _input.LA(1);
			} while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << When) | (1L << After) | (1L << Every) | (1L << Year) | (1L << Month) | (1L << Day) | (1L << Hour) | (1L << Minute) | (1L << Second) | (1L << If) | (1L << Repeat) | (1L << Set) | (1L << Allow) | (1L << Ban) | (1L << Week) | (1L << Comma) | (1L << Number) | (1L << Identifier))) != 0) );
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class StmtContext extends ParserRuleContext {
		public SimpleStmtContext simpleStmt() {
			return getRuleContext(SimpleStmtContext.class,0);
		}
		public ComplexStmtContext complexStmt() {
			return getRuleContext(ComplexStmtContext.class,0);
		}
		public StmtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_stmt; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof V3Visitor ) return ((V3Visitor<? extends T>)visitor).visitStmt(this);
			else return visitor.visitChildren(this);
		}
	}

	public final StmtContext stmt() throws RecognitionException {
		StmtContext _localctx = new StmtContext(_ctx, getState());
		enterRule(_localctx, 2, RULE_stmt);
		try {
			setState(49);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case When:
			case After:
			case Every:
			case Year:
			case Month:
			case Day:
			case Hour:
			case Minute:
			case Second:
			case Set:
			case Allow:
			case Ban:
			case Week:
			case Comma:
			case Number:
			case Identifier:
				enterOuterAlt(_localctx, 1);
				{
				setState(47);
				simpleStmt();
				}
				break;
			case If:
			case Repeat:
				enterOuterAlt(_localctx, 2);
				{
				setState(48);
				complexStmt();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SimpleStmtContext extends ParserRuleContext {
		public IntenseStmtContext intenseStmt() {
			return getRuleContext(IntenseStmtContext.class,0);
		}
		public ListenStmtContext listenStmt() {
			return getRuleContext(ListenStmtContext.class,0);
		}
		public ScheduleStmtContext scheduleStmt() {
			return getRuleContext(ScheduleStmtContext.class,0);
		}
		public SimpleStmtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_simpleStmt; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof V3Visitor ) return ((V3Visitor<? extends T>)visitor).visitSimpleStmt(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SimpleStmtContext simpleStmt() throws RecognitionException {
		SimpleStmtContext _localctx = new SimpleStmtContext(_ctx, getState());
		enterRule(_localctx, 4, RULE_simpleStmt);
		try {
			setState(54);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,2,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				setState(51);
				intenseStmt();
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(52);
				listenStmt();
				}
				break;
			case 3:
				enterOuterAlt(_localctx, 3);
				{
				setState(53);
				scheduleStmt();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class IntenseStmtContext extends ParserRuleContext {
		public AuthoriseStmtContext authoriseStmt() {
			return getRuleContext(AuthoriseStmtContext.class,0);
		}
		public RunToolStmtContext runToolStmt() {
			return getRuleContext(RunToolStmtContext.class,0);
		}
		public SetStmtContext setStmt() {
			return getRuleContext(SetStmtContext.class,0);
		}
		public IntenseStmtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_intenseStmt; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof V3Visitor ) return ((V3Visitor<? extends T>)visitor).visitIntenseStmt(this);
			else return visitor.visitChildren(this);
		}
	}

	public final IntenseStmtContext intenseStmt() throws RecognitionException {
		IntenseStmtContext _localctx = new IntenseStmtContext(_ctx, getState());
		enterRule(_localctx, 6, RULE_intenseStmt);
		try {
			setState(59);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case Allow:
			case Ban:
			case Week:
			case Comma:
			case Number:
				enterOuterAlt(_localctx, 1);
				{
				setState(56);
				authoriseStmt();
				}
				break;
			case Identifier:
				enterOuterAlt(_localctx, 2);
				{
				setState(57);
				runToolStmt();
				}
				break;
			case Set:
				enterOuterAlt(_localctx, 3);
				{
				setState(58);
				setStmt();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class RunToolStmtContext extends ParserRuleContext {
		public List<TerminalNode> Identifier() { return getTokens(V3Parser.Identifier); }
		public TerminalNode Identifier(int i) {
			return getToken(V3Parser.Identifier, i);
		}
		public PlaceContext place() {
			return getRuleContext(PlaceContext.class,0);
		}
		public TerminalNode Run() { return getToken(V3Parser.Run, 0); }
		public TerminalNode Tool_s() { return getToken(V3Parser.Tool_s, 0); }
		public TerminalNode Unit() { return getToken(V3Parser.Unit, 0); }
		public TerminalNode Return() { return getToken(V3Parser.Return, 0); }
		public TerminalNode Dot() { return getToken(V3Parser.Dot, 0); }
		public List<TerminalNode> Comma() { return getTokens(V3Parser.Comma); }
		public TerminalNode Comma(int i) {
			return getToken(V3Parser.Comma, i);
		}
		public List<ParamStmtContext> paramStmt() {
			return getRuleContexts(ParamStmtContext.class);
		}
		public ParamStmtContext paramStmt(int i) {
			return getRuleContext(ParamStmtContext.class,i);
		}
		public NotifyStmtContext notifyStmt() {
			return getRuleContext(NotifyStmtContext.class,0);
		}
		public RunToolStmtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_runToolStmt; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof V3Visitor ) return ((V3Visitor<? extends T>)visitor).visitRunToolStmt(this);
			else return visitor.visitChildren(this);
		}
	}

	public final RunToolStmtContext runToolStmt() throws RecognitionException {
		RunToolStmtContext _localctx = new RunToolStmtContext(_ctx, getState());
		enterRule(_localctx, 8, RULE_runToolStmt);
		try {
			int _alt;
			setState(86);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,7,_ctx) ) {
			case 1:
				enterOuterAlt(_localctx, 1);
				{
				{
				setState(61);
				match(Identifier);
				setState(62);
				place();
				setState(63);
				match(Run);
				setState(64);
				match(Identifier);
				setState(65);
				match(Tool_s);
				setState(66);
				match(Identifier);
				setState(67);
				match(Unit);
				setState(77);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) {
				case 1:
					{
					setState(68);
					match(Comma);
					}
					break;
				case 2:
					{
					setState(71); 
					_errHandler.sync(this);
					_alt = 1;
					do {
						switch (_alt) {
						case 1:
							{
							{
							setState(69);
							match(Comma);
							setState(70);
							paramStmt();
							}
							}
							break;
						default:
							throw new NoViableAltException(this);
						}
						setState(73); 
						_errHandler.sync(this);
						_alt = getInterpreter().adaptivePredict(_input,4,_ctx);
					} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
					setState(75);
					match(Comma);
					}
					break;
				}
				setState(79);
				match(Return);
				setState(80);
				match(Identifier);
				}
				setState(83);
				_errHandler.sync(this);
				switch ( getInterpreter().adaptivePredict(_input,6,_ctx) ) {
				case 1:
					{
					setState(82);
					match(Dot);
					}
					break;
				}
				}
				break;
			case 2:
				enterOuterAlt(_localctx, 2);
				{
				setState(85);
				notifyStmt();
				}
				break;
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class NotifyStmtContext extends ParserRuleContext {
		public List<TerminalNode> Identifier() { return getTokens(V3Parser.Identifier); }
		public TerminalNode Identifier(int i) {
			return getToken(V3Parser.Identifier, i);
		}
		public PlaceContext place() {
			return getRuleContext(PlaceContext.class,0);
		}
		public TerminalNode Run() { return getToken(V3Parser.Run, 0); }
		public TerminalNode ChatTool() { return getToken(V3Parser.ChatTool, 0); }
		public List<TerminalNode> Comma() { return getTokens(V3Parser.Comma); }
		public TerminalNode Comma(int i) {
			return getToken(V3Parser.Comma, i);
		}
		public TerminalNode ChatRoom() { return getToken(V3Parser.ChatRoom, 0); }
		public List<TerminalNode> Is() { return getTokens(V3Parser.Is); }
		public TerminalNode Is(int i) {
			return getToken(V3Parser.Is, i);
		}
		public TerminalNode MsgContent() { return getToken(V3Parser.MsgContent, 0); }
		public TerminalNode Reciver() { return getToken(V3Parser.Reciver, 0); }
		public TerminalNode Dot() { return getToken(V3Parser.Dot, 0); }
		public NotifyStmtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_notifyStmt; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof V3Visitor ) return ((V3Visitor<? extends T>)visitor).visitNotifyStmt(this);
			else return visitor.visitChildren(this);
		}
	}

	public final NotifyStmtContext notifyStmt() throws RecognitionException {
		NotifyStmtContext _localctx = new NotifyStmtContext(_ctx, getState());
		enterRule(_localctx, 10, RULE_notifyStmt);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(88);
			match(Identifier);
			setState(89);
			place();
			setState(90);
			match(Run);
			setState(91);
			match(ChatTool);
			setState(92);
			match(Comma);
			setState(93);
			match(ChatRoom);
			setState(94);
			match(Is);
			setState(95);
			match(Identifier);
			setState(100);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,8,_ctx) ) {
			case 1:
				{
				setState(96);
				match(Comma);
				setState(97);
				match(Reciver);
				setState(98);
				match(Is);
				setState(99);
				match(Identifier);
				}
				break;
			}
			setState(102);
			match(Comma);
			setState(103);
			match(MsgContent);
			setState(104);
			match(Is);
			setState(105);
			match(Identifier);
			setState(107);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,9,_ctx) ) {
			case 1:
				{
				setState(106);
				match(Dot);
				}
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ParamStmtContext extends ParserRuleContext {
		public List<TerminalNode> Identifier() { return getTokens(V3Parser.Identifier); }
		public TerminalNode Identifier(int i) {
			return getToken(V3Parser.Identifier, i);
		}
		public TerminalNode Is() { return getToken(V3Parser.Is, 0); }
		public ParamStmtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_paramStmt; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof V3Visitor ) return ((V3Visitor<? extends T>)visitor).visitParamStmt(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ParamStmtContext paramStmt() throws RecognitionException {
		ParamStmtContext _localctx = new ParamStmtContext(_ctx, getState());
		enterRule(_localctx, 12, RULE_paramStmt);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(109);
			match(Identifier);
			setState(110);
			match(Is);
			setState(111);
			match(Identifier);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class PlaceContext extends ParserRuleContext {
		public TerminalNode At() { return getToken(V3Parser.At, 0); }
		public TerminalNode Identifier() { return getToken(V3Parser.Identifier, 0); }
		public TerminalNode Band() { return getToken(V3Parser.Band, 0); }
		public PlaceContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_place; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof V3Visitor ) return ((V3Visitor<? extends T>)visitor).visitPlace(this);
			else return visitor.visitChildren(this);
		}
	}

	public final PlaceContext place() throws RecognitionException {
		PlaceContext _localctx = new PlaceContext(_ctx, getState());
		enterRule(_localctx, 14, RULE_place);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(113);
			match(At);
			setState(114);
			match(Identifier);
			setState(115);
			match(Band);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ListenStmtContext extends ParserRuleContext {
		public TerminalNode When() { return getToken(V3Parser.When, 0); }
		public PlaceContext place() {
			return getRuleContext(PlaceContext.class,0);
		}
		public TerminalNode Listen() { return getToken(V3Parser.Listen, 0); }
		public TerminalNode Identifier() { return getToken(V3Parser.Identifier, 0); }
		public TerminalNode Type_sMessage() { return getToken(V3Parser.Type_sMessage, 0); }
		public TerminalNode Comma() { return getToken(V3Parser.Comma, 0); }
		public TerminalNode Then() { return getToken(V3Parser.Then, 0); }
		public IntenseStmtContext intenseStmt() {
			return getRuleContext(IntenseStmtContext.class,0);
		}
		public ListenStmtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_listenStmt; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof V3Visitor ) return ((V3Visitor<? extends T>)visitor).visitListenStmt(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ListenStmtContext listenStmt() throws RecognitionException {
		ListenStmtContext _localctx = new ListenStmtContext(_ctx, getState());
		enterRule(_localctx, 16, RULE_listenStmt);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(117);
			match(When);
			setState(118);
			place();
			setState(119);
			match(Listen);
			setState(120);
			match(Identifier);
			setState(121);
			match(Type_sMessage);
			setState(122);
			match(Comma);
			setState(123);
			match(Then);
			setState(124);
			intenseStmt();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ScheduleStmtContext extends ParserRuleContext {
		public TimeAdverbialContext timeAdverbial() {
			return getRuleContext(TimeAdverbialContext.class,0);
		}
		public TerminalNode Comma() { return getToken(V3Parser.Comma, 0); }
		public IntenseStmtContext intenseStmt() {
			return getRuleContext(IntenseStmtContext.class,0);
		}
		public ListenStmtContext listenStmt() {
			return getRuleContext(ListenStmtContext.class,0);
		}
		public ScheduleStmtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_scheduleStmt; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof V3Visitor ) return ((V3Visitor<? extends T>)visitor).visitScheduleStmt(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ScheduleStmtContext scheduleStmt() throws RecognitionException {
		ScheduleStmtContext _localctx = new ScheduleStmtContext(_ctx, getState());
		enterRule(_localctx, 18, RULE_scheduleStmt);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(126);
			timeAdverbial();
			setState(127);
			match(Comma);
			setState(130);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case Set:
			case Allow:
			case Ban:
			case Week:
			case Comma:
			case Number:
			case Identifier:
				{
				setState(128);
				intenseStmt();
				}
				break;
			case When:
				{
				setState(129);
				listenStmt();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class TimeAdverbialContext extends ParserRuleContext {
		public PeriodContext period() {
			return getRuleContext(PeriodContext.class,0);
		}
		public DelayContext delay() {
			return getRuleContext(DelayContext.class,0);
		}
		public TimeAdverbialContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_timeAdverbial; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof V3Visitor ) return ((V3Visitor<? extends T>)visitor).visitTimeAdverbial(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TimeAdverbialContext timeAdverbial() throws RecognitionException {
		TimeAdverbialContext _localctx = new TimeAdverbialContext(_ctx, getState());
		enterRule(_localctx, 20, RULE_timeAdverbial);
		try {
			setState(134);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case Every:
				enterOuterAlt(_localctx, 1);
				{
				setState(132);
				period();
				}
				break;
			case After:
			case Year:
			case Month:
			case Day:
			case Hour:
			case Minute:
			case Second:
			case Number:
				enterOuterAlt(_localctx, 2);
				{
				setState(133);
				delay();
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class PeriodContext extends ParserRuleContext {
		public TerminalNode Every() { return getToken(V3Parser.Every, 0); }
		public List<TerminalNode> Number() { return getTokens(V3Parser.Number); }
		public TerminalNode Number(int i) {
			return getToken(V3Parser.Number, i);
		}
		public TerminalNode Year() { return getToken(V3Parser.Year, 0); }
		public TerminalNode Month() { return getToken(V3Parser.Month, 0); }
		public TerminalNode Day() { return getToken(V3Parser.Day, 0); }
		public TerminalNode Hour() { return getToken(V3Parser.Hour, 0); }
		public TerminalNode Minute() { return getToken(V3Parser.Minute, 0); }
		public TerminalNode Second() { return getToken(V3Parser.Second, 0); }
		public PeriodContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_period; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof V3Visitor ) return ((V3Visitor<? extends T>)visitor).visitPeriod(this);
			else return visitor.visitChildren(this);
		}
	}

	public final PeriodContext period() throws RecognitionException {
		PeriodContext _localctx = new PeriodContext(_ctx, getState());
		enterRule(_localctx, 22, RULE_period);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(136);
			match(Every);
			setState(142);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,13,_ctx) ) {
			case 1:
				{
				setState(138);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Year) {
					{
					setState(137);
					match(Year);
					}
				}

				}
				break;
			case 2:
				{
				setState(140);
				match(Number);
				setState(141);
				match(Year);
				}
				break;
			}
			setState(149);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,15,_ctx) ) {
			case 1:
				{
				setState(145);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Month) {
					{
					setState(144);
					match(Month);
					}
				}

				}
				break;
			case 2:
				{
				setState(147);
				match(Number);
				setState(148);
				match(Month);
				}
				break;
			}
			setState(156);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,17,_ctx) ) {
			case 1:
				{
				setState(152);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Day) {
					{
					setState(151);
					match(Day);
					}
				}

				}
				break;
			case 2:
				{
				setState(154);
				match(Number);
				setState(155);
				match(Day);
				}
				break;
			}
			setState(163);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,19,_ctx) ) {
			case 1:
				{
				setState(159);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Hour) {
					{
					setState(158);
					match(Hour);
					}
				}

				}
				break;
			case 2:
				{
				setState(161);
				match(Number);
				setState(162);
				match(Hour);
				}
				break;
			}
			setState(170);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,21,_ctx) ) {
			case 1:
				{
				setState(166);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Minute) {
					{
					setState(165);
					match(Minute);
					}
				}

				}
				break;
			case 2:
				{
				setState(168);
				match(Number);
				setState(169);
				match(Minute);
				}
				break;
			}
			setState(177);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case Second:
			case Comma:
				{
				setState(173);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Second) {
					{
					setState(172);
					match(Second);
					}
				}

				}
				break;
			case Number:
				{
				setState(175);
				match(Number);
				setState(176);
				match(Second);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class DelayContext extends ParserRuleContext {
		public TerminalNode After() { return getToken(V3Parser.After, 0); }
		public List<TerminalNode> Number() { return getTokens(V3Parser.Number); }
		public TerminalNode Number(int i) {
			return getToken(V3Parser.Number, i);
		}
		public TerminalNode Year() { return getToken(V3Parser.Year, 0); }
		public TerminalNode Month() { return getToken(V3Parser.Month, 0); }
		public TerminalNode Day() { return getToken(V3Parser.Day, 0); }
		public TerminalNode Hour() { return getToken(V3Parser.Hour, 0); }
		public TerminalNode Minute() { return getToken(V3Parser.Minute, 0); }
		public TerminalNode Second() { return getToken(V3Parser.Second, 0); }
		public DelayContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_delay; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof V3Visitor ) return ((V3Visitor<? extends T>)visitor).visitDelay(this);
			else return visitor.visitChildren(this);
		}
	}

	public final DelayContext delay() throws RecognitionException {
		DelayContext _localctx = new DelayContext(_ctx, getState());
		enterRule(_localctx, 24, RULE_delay);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(184);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) {
			case 1:
				{
				setState(180);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Year) {
					{
					setState(179);
					match(Year);
					}
				}

				}
				break;
			case 2:
				{
				setState(182);
				match(Number);
				setState(183);
				match(Year);
				}
				break;
			}
			setState(191);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,27,_ctx) ) {
			case 1:
				{
				setState(187);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Month) {
					{
					setState(186);
					match(Month);
					}
				}

				}
				break;
			case 2:
				{
				setState(189);
				match(Number);
				setState(190);
				match(Month);
				}
				break;
			}
			setState(198);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,29,_ctx) ) {
			case 1:
				{
				setState(194);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Day) {
					{
					setState(193);
					match(Day);
					}
				}

				}
				break;
			case 2:
				{
				setState(196);
				match(Number);
				setState(197);
				match(Day);
				}
				break;
			}
			setState(205);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,31,_ctx) ) {
			case 1:
				{
				setState(201);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Hour) {
					{
					setState(200);
					match(Hour);
					}
				}

				}
				break;
			case 2:
				{
				setState(203);
				match(Number);
				setState(204);
				match(Hour);
				}
				break;
			}
			setState(212);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,33,_ctx) ) {
			case 1:
				{
				setState(208);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Minute) {
					{
					setState(207);
					match(Minute);
					}
				}

				}
				break;
			case 2:
				{
				setState(210);
				match(Number);
				setState(211);
				match(Minute);
				}
				break;
			}
			setState(219);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case After:
			case Second:
				{
				setState(215);
				_errHandler.sync(this);
				_la = _input.LA(1);
				if (_la==Second) {
					{
					setState(214);
					match(Second);
					}
				}

				}
				break;
			case Number:
				{
				setState(217);
				match(Number);
				setState(218);
				match(Second);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			setState(221);
			match(After);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ComplexStmtContext extends ParserRuleContext {
		public List<IfStmtContext> ifStmt() {
			return getRuleContexts(IfStmtContext.class);
		}
		public IfStmtContext ifStmt(int i) {
			return getRuleContext(IfStmtContext.class,i);
		}
		public List<LoopStmtContext> loopStmt() {
			return getRuleContexts(LoopStmtContext.class);
		}
		public LoopStmtContext loopStmt(int i) {
			return getRuleContext(LoopStmtContext.class,i);
		}
		public ComplexStmtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_complexStmt; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof V3Visitor ) return ((V3Visitor<? extends T>)visitor).visitComplexStmt(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ComplexStmtContext complexStmt() throws RecognitionException {
		ComplexStmtContext _localctx = new ComplexStmtContext(_ctx, getState());
		enterRule(_localctx, 26, RULE_complexStmt);
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(225); 
			_errHandler.sync(this);
			_alt = 1;
			do {
				switch (_alt) {
				case 1:
					{
					setState(225);
					_errHandler.sync(this);
					switch (_input.LA(1)) {
					case If:
						{
						setState(223);
						ifStmt();
						}
						break;
					case Repeat:
						{
						setState(224);
						loopStmt();
						}
						break;
					default:
						throw new NoViableAltException(this);
					}
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				setState(227); 
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,37,_ctx);
			} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class IfStmtContext extends ParserRuleContext {
		public TerminalNode If() { return getToken(V3Parser.If, 0); }
		public ConditionStmtContext conditionStmt() {
			return getRuleContext(ConditionStmtContext.class,0);
		}
		public TerminalNode Comma() { return getToken(V3Parser.Comma, 0); }
		public TerminalNode Then() { return getToken(V3Parser.Then, 0); }
		public SimpleStmtContext simpleStmt() {
			return getRuleContext(SimpleStmtContext.class,0);
		}
		public IfStmtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_ifStmt; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof V3Visitor ) return ((V3Visitor<? extends T>)visitor).visitIfStmt(this);
			else return visitor.visitChildren(this);
		}
	}

	public final IfStmtContext ifStmt() throws RecognitionException {
		IfStmtContext _localctx = new IfStmtContext(_ctx, getState());
		enterRule(_localctx, 28, RULE_ifStmt);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(229);
			match(If);
			setState(230);
			conditionStmt();
			setState(231);
			match(Comma);
			setState(232);
			match(Then);
			setState(233);
			simpleStmt();
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ConditionStmtContext extends ParserRuleContext {
		public List<TerminalNode> Identifier() { return getTokens(V3Parser.Identifier); }
		public TerminalNode Identifier(int i) {
			return getToken(V3Parser.Identifier, i);
		}
		public TerminalNode Operate() { return getToken(V3Parser.Operate, 0); }
		public ConditionStmtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_conditionStmt; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof V3Visitor ) return ((V3Visitor<? extends T>)visitor).visitConditionStmt(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ConditionStmtContext conditionStmt() throws RecognitionException {
		ConditionStmtContext _localctx = new ConditionStmtContext(_ctx, getState());
		enterRule(_localctx, 30, RULE_conditionStmt);
		try {
			enterOuterAlt(_localctx, 1);
			{
			{
			setState(235);
			match(Identifier);
			setState(236);
			match(Operate);
			setState(237);
			match(Identifier);
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class LoopStmtContext extends ParserRuleContext {
		public TerminalNode Repeat() { return getToken(V3Parser.Repeat, 0); }
		public SimpleStmtContext simpleStmt() {
			return getRuleContext(SimpleStmtContext.class,0);
		}
		public TerminalNode Identifier() { return getToken(V3Parser.Identifier, 0); }
		public TerminalNode Times() { return getToken(V3Parser.Times, 0); }
		public LoopStmtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_loopStmt; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof V3Visitor ) return ((V3Visitor<? extends T>)visitor).visitLoopStmt(this);
			else return visitor.visitChildren(this);
		}
	}

	public final LoopStmtContext loopStmt() throws RecognitionException {
		LoopStmtContext _localctx = new LoopStmtContext(_ctx, getState());
		enterRule(_localctx, 32, RULE_loopStmt);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(239);
			match(Repeat);
			setState(240);
			simpleStmt();
			setState(241);
			match(Identifier);
			setState(242);
			match(Times);
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class SetStmtContext extends ParserRuleContext {
		public TerminalNode Set() { return getToken(V3Parser.Set, 0); }
		public List<TerminalNode> Identifier() { return getTokens(V3Parser.Identifier); }
		public TerminalNode Identifier(int i) {
			return getToken(V3Parser.Identifier, i);
		}
		public List<TerminalNode> Is() { return getTokens(V3Parser.Is); }
		public TerminalNode Is(int i) {
			return getToken(V3Parser.Is, i);
		}
		public List<ValueContext> value() {
			return getRuleContexts(ValueContext.class);
		}
		public ValueContext value(int i) {
			return getRuleContext(ValueContext.class,i);
		}
		public TerminalNode Dot() { return getToken(V3Parser.Dot, 0); }
		public List<TerminalNode> Comma() { return getTokens(V3Parser.Comma); }
		public TerminalNode Comma(int i) {
			return getToken(V3Parser.Comma, i);
		}
		public SetStmtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_setStmt; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof V3Visitor ) return ((V3Visitor<? extends T>)visitor).visitSetStmt(this);
			else return visitor.visitChildren(this);
		}
	}

	public final SetStmtContext setStmt() throws RecognitionException {
		SetStmtContext _localctx = new SetStmtContext(_ctx, getState());
		enterRule(_localctx, 34, RULE_setStmt);
		int _la;
		try {
			int _alt;
			enterOuterAlt(_localctx, 1);
			{
			setState(244);
			match(Set);
			setState(251); 
			_errHandler.sync(this);
			_alt = 1;
			do {
				switch (_alt) {
				case 1:
					{
					{
					setState(246);
					_errHandler.sync(this);
					_la = _input.LA(1);
					if (_la==Comma) {
						{
						setState(245);
						match(Comma);
						}
					}

					setState(248);
					match(Identifier);
					setState(249);
					match(Is);
					setState(250);
					value();
					}
					}
					break;
				default:
					throw new NoViableAltException(this);
				}
				setState(253); 
				_errHandler.sync(this);
				_alt = getInterpreter().adaptivePredict(_input,39,_ctx);
			} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
			setState(256);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,40,_ctx) ) {
			case 1:
				{
				setState(255);
				match(Dot);
				}
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class ValueContext extends ParserRuleContext {
		public ComplexStmtContext complexStmt() {
			return getRuleContext(ComplexStmtContext.class,0);
		}
		public SimpleStmtContext simpleStmt() {
			return getRuleContext(SimpleStmtContext.class,0);
		}
		public TerminalNode Identifier() { return getToken(V3Parser.Identifier, 0); }
		public ValueContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_value; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof V3Visitor ) return ((V3Visitor<? extends T>)visitor).visitValue(this);
			else return visitor.visitChildren(this);
		}
	}

	public final ValueContext value() throws RecognitionException {
		ValueContext _localctx = new ValueContext(_ctx, getState());
		enterRule(_localctx, 36, RULE_value);
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(261);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,41,_ctx) ) {
			case 1:
				{
				setState(258);
				complexStmt();
				}
				break;
			case 2:
				{
				setState(259);
				simpleStmt();
				}
				break;
			case 3:
				{
				setState(260);
				match(Identifier);
				}
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class AuthoriseStmtContext extends ParserRuleContext {
		public List<TerminalNode> Identifier() { return getTokens(V3Parser.Identifier); }
		public TerminalNode Identifier(int i) {
			return getToken(V3Parser.Identifier, i);
		}
		public PlaceContext place() {
			return getRuleContext(PlaceContext.class,0);
		}
		public TerminalNode Run() { return getToken(V3Parser.Run, 0); }
		public TerminalNode Allow() { return getToken(V3Parser.Allow, 0); }
		public TerminalNode Ban() { return getToken(V3Parser.Ban, 0); }
		public TerminalNode Tool() { return getToken(V3Parser.Tool, 0); }
		public TerminalNode Tool_s() { return getToken(V3Parser.Tool_s, 0); }
		public TerminalNode Unit() { return getToken(V3Parser.Unit, 0); }
		public TimeFrameContext timeFrame() {
			return getRuleContext(TimeFrameContext.class,0);
		}
		public TerminalNode Comma() { return getToken(V3Parser.Comma, 0); }
		public TerminalNode Dot() { return getToken(V3Parser.Dot, 0); }
		public AuthoriseStmtContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_authoriseStmt; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof V3Visitor ) return ((V3Visitor<? extends T>)visitor).visitAuthoriseStmt(this);
			else return visitor.visitChildren(this);
		}
	}

	public final AuthoriseStmtContext authoriseStmt() throws RecognitionException {
		AuthoriseStmtContext _localctx = new AuthoriseStmtContext(_ctx, getState());
		enterRule(_localctx, 38, RULE_authoriseStmt);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(266);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << Week) | (1L << Comma) | (1L << Number))) != 0)) {
				{
				setState(263);
				timeFrame();
				setState(264);
				match(Comma);
				}
			}

			setState(268);
			_la = _input.LA(1);
			if ( !(_la==Allow || _la==Ban) ) {
			_errHandler.recoverInline(this);
			}
			else {
				if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
				_errHandler.reportMatch(this);
				consume();
			}
			setState(269);
			match(Identifier);
			setState(270);
			place();
			setState(271);
			match(Run);
			setState(272);
			match(Identifier);
			setState(277);
			_errHandler.sync(this);
			switch (_input.LA(1)) {
			case Tool:
				{
				setState(273);
				match(Tool);
				}
				break;
			case Tool_s:
				{
				setState(274);
				match(Tool_s);
				setState(275);
				match(Identifier);
				setState(276);
				match(Unit);
				}
				break;
			default:
				throw new NoViableAltException(this);
			}
			setState(280);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,44,_ctx) ) {
			case 1:
				{
				setState(279);
				match(Dot);
				}
				break;
			}
			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static class TimeFrameContext extends ParserRuleContext {
		public List<TerminalNode> Number() { return getTokens(V3Parser.Number); }
		public TerminalNode Number(int i) {
			return getToken(V3Parser.Number, i);
		}
		public List<TerminalNode> Month() { return getTokens(V3Parser.Month); }
		public TerminalNode Month(int i) {
			return getToken(V3Parser.Month, i);
		}
		public List<TerminalNode> To() { return getTokens(V3Parser.To); }
		public TerminalNode To(int i) {
			return getToken(V3Parser.To, i);
		}
		public List<TerminalNode> Day() { return getTokens(V3Parser.Day); }
		public TerminalNode Day(int i) {
			return getToken(V3Parser.Day, i);
		}
		public List<TerminalNode> Week() { return getTokens(V3Parser.Week); }
		public TerminalNode Week(int i) {
			return getToken(V3Parser.Week, i);
		}
		public List<TerminalNode> Hour() { return getTokens(V3Parser.Hour); }
		public TerminalNode Hour(int i) {
			return getToken(V3Parser.Hour, i);
		}
		public List<TerminalNode> Minute() { return getTokens(V3Parser.Minute); }
		public TerminalNode Minute(int i) {
			return getToken(V3Parser.Minute, i);
		}
		public List<TerminalNode> Second() { return getTokens(V3Parser.Second); }
		public TerminalNode Second(int i) {
			return getToken(V3Parser.Second, i);
		}
		public TimeFrameContext(ParserRuleContext parent, int invokingState) {
			super(parent, invokingState);
		}
		@Override public int getRuleIndex() { return RULE_timeFrame; }
		@Override
		public <T> T accept(ParseTreeVisitor<? extends T> visitor) {
			if ( visitor instanceof V3Visitor ) return ((V3Visitor<? extends T>)visitor).visitTimeFrame(this);
			else return visitor.visitChildren(this);
		}
	}

	public final TimeFrameContext timeFrame() throws RecognitionException {
		TimeFrameContext _localctx = new TimeFrameContext(_ctx, getState());
		enterRule(_localctx, 40, RULE_timeFrame);
		int _la;
		try {
			enterOuterAlt(_localctx, 1);
			{
			setState(287);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,45,_ctx) ) {
			case 1:
				{
				setState(282);
				match(Number);
				setState(283);
				match(Month);
				setState(284);
				match(To);
				setState(285);
				match(Number);
				setState(286);
				match(Month);
				}
				break;
			}
			setState(294);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,46,_ctx) ) {
			case 1:
				{
				setState(289);
				match(Number);
				setState(290);
				match(Day);
				setState(291);
				match(To);
				setState(292);
				match(Day);
				setState(293);
				match(Month);
				}
				break;
			}
			setState(301);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==Week) {
				{
				setState(296);
				match(Week);
				setState(297);
				match(Number);
				setState(298);
				match(To);
				setState(299);
				match(Week);
				setState(300);
				match(Number);
				}
			}

			setState(308);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,48,_ctx) ) {
			case 1:
				{
				setState(303);
				match(Number);
				setState(304);
				match(Hour);
				setState(305);
				match(To);
				setState(306);
				match(Number);
				setState(307);
				match(Hour);
				}
				break;
			}
			setState(315);
			_errHandler.sync(this);
			switch ( getInterpreter().adaptivePredict(_input,49,_ctx) ) {
			case 1:
				{
				setState(310);
				match(Number);
				setState(311);
				match(Minute);
				setState(312);
				match(To);
				setState(313);
				match(Number);
				setState(314);
				match(Minute);
				}
				break;
			}
			setState(322);
			_errHandler.sync(this);
			_la = _input.LA(1);
			if (_la==Number) {
				{
				setState(317);
				match(Number);
				setState(318);
				match(Second);
				setState(319);
				match(To);
				setState(320);
				match(Number);
				setState(321);
				match(Second);
				}
			}

			}
		}
		catch (RecognitionException re) {
			_localctx.exception = re;
			_errHandler.reportError(this, re);
			_errHandler.recover(this, re);
		}
		finally {
			exitRule();
		}
		return _localctx;
	}

	public static final String _serializedATN =
		"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3*\u0147\4\2\t\2\4"+
		"\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t"+
		"\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+
		"\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\3\2\6\2.\n\2\r\2\16\2/\3\3\3"+
		"\3\5\3\64\n\3\3\4\3\4\3\4\5\49\n\4\3\5\3\5\3\5\5\5>\n\5\3\6\3\6\3\6\3"+
		"\6\3\6\3\6\3\6\3\6\3\6\3\6\6\6J\n\6\r\6\16\6K\3\6\3\6\5\6P\n\6\3\6\3\6"+
		"\3\6\3\6\5\6V\n\6\3\6\5\6Y\n\6\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7"+
		"\3\7\3\7\5\7g\n\7\3\7\3\7\3\7\3\7\3\7\5\7n\n\7\3\b\3\b\3\b\3\b\3\t\3\t"+
		"\3\t\3\t\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\13\3\13\3\13\3\13\5\13"+
		"\u0085\n\13\3\f\3\f\5\f\u0089\n\f\3\r\3\r\5\r\u008d\n\r\3\r\3\r\5\r\u0091"+
		"\n\r\3\r\5\r\u0094\n\r\3\r\3\r\5\r\u0098\n\r\3\r\5\r\u009b\n\r\3\r\3\r"+
		"\5\r\u009f\n\r\3\r\5\r\u00a2\n\r\3\r\3\r\5\r\u00a6\n\r\3\r\5\r\u00a9\n"+
		"\r\3\r\3\r\5\r\u00ad\n\r\3\r\5\r\u00b0\n\r\3\r\3\r\5\r\u00b4\n\r\3\16"+
		"\5\16\u00b7\n\16\3\16\3\16\5\16\u00bb\n\16\3\16\5\16\u00be\n\16\3\16\3"+
		"\16\5\16\u00c2\n\16\3\16\5\16\u00c5\n\16\3\16\3\16\5\16\u00c9\n\16\3\16"+
		"\5\16\u00cc\n\16\3\16\3\16\5\16\u00d0\n\16\3\16\5\16\u00d3\n\16\3\16\3"+
		"\16\5\16\u00d7\n\16\3\16\5\16\u00da\n\16\3\16\3\16\5\16\u00de\n\16\3\16"+
		"\3\16\3\17\3\17\6\17\u00e4\n\17\r\17\16\17\u00e5\3\20\3\20\3\20\3\20\3"+
		"\20\3\20\3\21\3\21\3\21\3\21\3\22\3\22\3\22\3\22\3\22\3\23\3\23\5\23\u00f9"+
		"\n\23\3\23\3\23\3\23\6\23\u00fe\n\23\r\23\16\23\u00ff\3\23\5\23\u0103"+
		"\n\23\3\24\3\24\3\24\5\24\u0108\n\24\3\25\3\25\3\25\5\25\u010d\n\25\3"+
		"\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\5\25\u0118\n\25\3\25\5\25"+
		"\u011b\n\25\3\26\3\26\3\26\3\26\3\26\5\26\u0122\n\26\3\26\3\26\3\26\3"+
		"\26\3\26\5\26\u0129\n\26\3\26\3\26\3\26\3\26\3\26\5\26\u0130\n\26\3\26"+
		"\3\26\3\26\3\26\3\26\5\26\u0137\n\26\3\26\3\26\3\26\3\26\3\26\5\26\u013e"+
		"\n\26\3\26\3\26\3\26\3\26\3\26\5\26\u0145\n\26\3\26\2\2\27\2\4\6\b\n\f"+
		"\16\20\22\24\26\30\32\34\36 \"$&(*\2\3\3\2\"#\2\u0167\2-\3\2\2\2\4\63"+
		"\3\2\2\2\68\3\2\2\2\b=\3\2\2\2\nX\3\2\2\2\fZ\3\2\2\2\16o\3\2\2\2\20s\3"+
		"\2\2\2\22w\3\2\2\2\24\u0080\3\2\2\2\26\u0088\3\2\2\2\30\u008a\3\2\2\2"+
		"\32\u00ba\3\2\2\2\34\u00e3\3\2\2\2\36\u00e7\3\2\2\2 \u00ed\3\2\2\2\"\u00f1"+
		"\3\2\2\2$\u00f6\3\2\2\2&\u0107\3\2\2\2(\u010c\3\2\2\2*\u0121\3\2\2\2,"+
		".\5\4\3\2-,\3\2\2\2./\3\2\2\2/-\3\2\2\2/\60\3\2\2\2\60\3\3\2\2\2\61\64"+
		"\5\6\4\2\62\64\5\34\17\2\63\61\3\2\2\2\63\62\3\2\2\2\64\5\3\2\2\2\659"+
		"\5\b\5\2\669\5\22\n\2\679\5\24\13\28\65\3\2\2\28\66\3\2\2\28\67\3\2\2"+
		"\29\7\3\2\2\2:>\5(\25\2;>\5\n\6\2<>\5$\23\2=:\3\2\2\2=;\3\2\2\2=<\3\2"+
		"\2\2>\t\3\2\2\2?@\7(\2\2@A\5\20\t\2AB\7\5\2\2BC\7(\2\2CD\7\6\2\2DE\7("+
		"\2\2EO\7\7\2\2FP\7%\2\2GH\7%\2\2HJ\5\16\b\2IG\3\2\2\2JK\3\2\2\2KI\3\2"+
		"\2\2KL\3\2\2\2LM\3\2\2\2MN\7%\2\2NP\3\2\2\2OF\3\2\2\2OI\3\2\2\2PQ\3\2"+
		"\2\2QR\7\t\2\2RS\7(\2\2SU\3\2\2\2TV\7&\2\2UT\3\2\2\2UV\3\2\2\2VY\3\2\2"+
		"\2WY\5\f\7\2X?\3\2\2\2XW\3\2\2\2Y\13\3\2\2\2Z[\7(\2\2[\\\5\20\t\2\\]\7"+
		"\5\2\2]^\7\20\2\2^_\7%\2\2_`\7\21\2\2`a\7\b\2\2af\7(\2\2bc\7%\2\2cd\7"+
		"\23\2\2de\7\b\2\2eg\7(\2\2fb\3\2\2\2fg\3\2\2\2gh\3\2\2\2hi\7%\2\2ij\7"+
		"\22\2\2jk\7\b\2\2km\7(\2\2ln\7&\2\2ml\3\2\2\2mn\3\2\2\2n\r\3\2\2\2op\7"+
		"(\2\2pq\7\b\2\2qr\7(\2\2r\17\3\2\2\2st\7\3\2\2tu\7(\2\2uv\7\4\2\2v\21"+
		"\3\2\2\2wx\7\13\2\2xy\5\20\t\2yz\7\f\2\2z{\7(\2\2{|\7\16\2\2|}\7%\2\2"+
		"}~\7\17\2\2~\177\5\b\5\2\177\23\3\2\2\2\u0080\u0081\5\26\f\2\u0081\u0084"+
		"\7%\2\2\u0082\u0085\5\b\5\2\u0083\u0085\5\22\n\2\u0084\u0082\3\2\2\2\u0084"+
		"\u0083\3\2\2\2\u0085\25\3\2\2\2\u0086\u0089\5\30\r\2\u0087\u0089\5\32"+
		"\16\2\u0088\u0086\3\2\2\2\u0088\u0087\3\2\2\2\u0089\27\3\2\2\2\u008a\u0090"+
		"\7\25\2\2\u008b\u008d\7\26\2\2\u008c\u008b\3\2\2\2\u008c\u008d\3\2\2\2"+
		"\u008d\u0091\3\2\2\2\u008e\u008f\7\'\2\2\u008f\u0091\7\26\2\2\u0090\u008c"+
		"\3\2\2\2\u0090\u008e\3\2\2\2\u0091\u0097\3\2\2\2\u0092\u0094\7\27\2\2"+
		"\u0093\u0092\3\2\2\2\u0093\u0094\3\2\2\2\u0094\u0098\3\2\2\2\u0095\u0096"+
		"\7\'\2\2\u0096\u0098\7\27\2\2\u0097\u0093\3\2\2\2\u0097\u0095\3\2\2\2"+
		"\u0098\u009e\3\2\2\2\u0099\u009b\7\30\2\2\u009a\u0099\3\2\2\2\u009a\u009b"+
		"\3\2\2\2\u009b\u009f\3\2\2\2\u009c\u009d\7\'\2\2\u009d\u009f\7\30\2\2"+
		"\u009e\u009a\3\2\2\2\u009e\u009c\3\2\2\2\u009f\u00a5\3\2\2\2\u00a0\u00a2"+
		"\7\31\2\2\u00a1\u00a0\3\2\2\2\u00a1\u00a2\3\2\2\2\u00a2\u00a6\3\2\2\2"+
		"\u00a3\u00a4\7\'\2\2\u00a4\u00a6\7\31\2\2\u00a5\u00a1\3\2\2\2\u00a5\u00a3"+
		"\3\2\2\2\u00a6\u00ac\3\2\2\2\u00a7\u00a9\7\32\2\2\u00a8\u00a7\3\2\2\2"+
		"\u00a8\u00a9\3\2\2\2\u00a9\u00ad\3\2\2\2\u00aa\u00ab\7\'\2\2\u00ab\u00ad"+
		"\7\32\2\2\u00ac\u00a8\3\2\2\2\u00ac\u00aa\3\2\2\2\u00ad\u00b3\3\2\2\2"+
		"\u00ae\u00b0\7\33\2\2\u00af\u00ae\3\2\2\2\u00af\u00b0\3\2\2\2\u00b0\u00b4"+
		"\3\2\2\2\u00b1\u00b2\7\'\2\2\u00b2\u00b4\7\33\2\2\u00b3\u00af\3\2\2\2"+
		"\u00b3\u00b1\3\2\2\2\u00b4\31\3\2\2\2\u00b5\u00b7\7\26\2\2\u00b6\u00b5"+
		"\3\2\2\2\u00b6\u00b7\3\2\2\2\u00b7\u00bb\3\2\2\2\u00b8\u00b9\7\'\2\2\u00b9"+
		"\u00bb\7\26\2\2\u00ba\u00b6\3\2\2\2\u00ba\u00b8\3\2\2\2\u00bb\u00c1\3"+
		"\2\2\2\u00bc\u00be\7\27\2\2\u00bd\u00bc\3\2\2\2\u00bd\u00be\3\2\2\2\u00be"+
		"\u00c2\3\2\2\2\u00bf\u00c0\7\'\2\2\u00c0\u00c2\7\27\2\2\u00c1\u00bd\3"+
		"\2\2\2\u00c1\u00bf\3\2\2\2\u00c2\u00c8\3\2\2\2\u00c3\u00c5\7\30\2\2\u00c4"+
		"\u00c3\3\2\2\2\u00c4\u00c5\3\2\2\2\u00c5\u00c9\3\2\2\2\u00c6\u00c7\7\'"+
		"\2\2\u00c7\u00c9\7\30\2\2\u00c8\u00c4\3\2\2\2\u00c8\u00c6\3\2\2\2\u00c9"+
		"\u00cf\3\2\2\2\u00ca\u00cc\7\31\2\2\u00cb\u00ca\3\2\2\2\u00cb\u00cc\3"+
		"\2\2\2\u00cc\u00d0\3\2\2\2\u00cd\u00ce\7\'\2\2\u00ce\u00d0\7\31\2\2\u00cf"+
		"\u00cb\3\2\2\2\u00cf\u00cd\3\2\2\2\u00d0\u00d6\3\2\2\2\u00d1\u00d3\7\32"+
		"\2\2\u00d2\u00d1\3\2\2\2\u00d2\u00d3\3\2\2\2\u00d3\u00d7\3\2\2\2\u00d4"+
		"\u00d5\7\'\2\2\u00d5\u00d7\7\32\2\2\u00d6\u00d2\3\2\2\2\u00d6\u00d4\3"+
		"\2\2\2\u00d7\u00dd\3\2\2\2\u00d8\u00da\7\33\2\2\u00d9\u00d8\3\2\2\2\u00d9"+
		"\u00da\3\2\2\2\u00da\u00de\3\2\2\2\u00db\u00dc\7\'\2\2\u00dc\u00de\7\33"+
		"\2\2\u00dd\u00d9\3\2\2\2\u00dd\u00db\3\2\2\2\u00de\u00df\3\2\2\2\u00df"+
		"\u00e0\7\24\2\2\u00e0\33\3\2\2\2\u00e1\u00e4\5\36\20\2\u00e2\u00e4\5\""+
		"\22\2\u00e3\u00e1\3\2\2\2\u00e3\u00e2\3\2\2\2\u00e4\u00e5\3\2\2\2\u00e5"+
		"\u00e3\3\2\2\2\u00e5\u00e6\3\2\2\2\u00e6\35\3\2\2\2\u00e7\u00e8\7\34\2"+
		"\2\u00e8\u00e9\5 \21\2\u00e9\u00ea\7%\2\2\u00ea\u00eb\7\17\2\2\u00eb\u00ec"+
		"\5\6\4\2\u00ec\37\3\2\2\2\u00ed\u00ee\7(\2\2\u00ee\u00ef\7\35\2\2\u00ef"+
		"\u00f0\7(\2\2\u00f0!\3\2\2\2\u00f1\u00f2\7\36\2\2\u00f2\u00f3\5\6\4\2"+
		"\u00f3\u00f4\7(\2\2\u00f4\u00f5\7\37\2\2\u00f5#\3\2\2\2\u00f6\u00fd\7"+
		" \2\2\u00f7\u00f9\7%\2\2\u00f8\u00f7\3\2\2\2\u00f8\u00f9\3\2\2\2\u00f9"+
		"\u00fa\3\2\2\2\u00fa\u00fb\7(\2\2\u00fb\u00fc\7\b\2\2\u00fc\u00fe\5&\24"+
		"\2\u00fd\u00f8\3\2\2\2\u00fe\u00ff\3\2\2\2\u00ff\u00fd\3\2\2\2\u00ff\u0100"+
		"\3\2\2\2\u0100\u0102\3\2\2\2\u0101\u0103\7&\2\2\u0102\u0101\3\2\2\2\u0102"+
		"\u0103\3\2\2\2\u0103%\3\2\2\2\u0104\u0108\5\34\17\2\u0105\u0108\5\6\4"+
		"\2\u0106\u0108\7(\2\2\u0107\u0104\3\2\2\2\u0107\u0105\3\2\2\2\u0107\u0106"+
		"\3\2\2\2\u0108\'\3\2\2\2\u0109\u010a\5*\26\2\u010a\u010b\7%\2\2\u010b"+
		"\u010d\3\2\2\2\u010c\u0109\3\2\2\2\u010c\u010d\3\2\2\2\u010d\u010e\3\2"+
		"\2\2\u010e\u010f\t\2\2\2\u010f\u0110\7(\2\2\u0110\u0111\5\20\t\2\u0111"+
		"\u0112\7\5\2\2\u0112\u0117\7(\2\2\u0113\u0118\7\n\2\2\u0114\u0115\7\6"+
		"\2\2\u0115\u0116\7(\2\2\u0116\u0118\7\7\2\2\u0117\u0113\3\2\2\2\u0117"+
		"\u0114\3\2\2\2\u0118\u011a\3\2\2\2\u0119\u011b\7&\2\2\u011a\u0119\3\2"+
		"\2\2\u011a\u011b\3\2\2\2\u011b)\3\2\2\2\u011c\u011d\7\'\2\2\u011d\u011e"+
		"\7\27\2\2\u011e\u011f\7!\2\2\u011f\u0120\7\'\2\2\u0120\u0122\7\27\2\2"+
		"\u0121\u011c\3\2\2\2\u0121\u0122\3\2\2\2\u0122\u0128\3\2\2\2\u0123\u0124"+
		"\7\'\2\2\u0124\u0125\7\30\2\2\u0125\u0126\7!\2\2\u0126\u0127\7\30\2\2"+
		"\u0127\u0129\7\27\2\2\u0128\u0123\3\2\2\2\u0128\u0129\3\2\2\2\u0129\u012f"+
		"\3\2\2\2\u012a\u012b\7$\2\2\u012b\u012c\7\'\2\2\u012c\u012d\7!\2\2\u012d"+
		"\u012e\7$\2\2\u012e\u0130\7\'\2\2\u012f\u012a\3\2\2\2\u012f\u0130\3\2"+
		"\2\2\u0130\u0136\3\2\2\2\u0131\u0132\7\'\2\2\u0132\u0133\7\31\2\2\u0133"+
		"\u0134\7!\2\2\u0134\u0135\7\'\2\2\u0135\u0137\7\31\2\2\u0136\u0131\3\2"+
		"\2\2\u0136\u0137\3\2\2\2\u0137\u013d\3\2\2\2\u0138\u0139\7\'\2\2\u0139"+
		"\u013a\7\32\2\2\u013a\u013b\7!\2\2\u013b\u013c\7\'\2\2\u013c\u013e\7\32"+
		"\2\2\u013d\u0138\3\2\2\2\u013d\u013e\3\2\2\2\u013e\u0144\3\2\2\2\u013f"+
		"\u0140\7\'\2\2\u0140\u0141\7\33\2\2\u0141\u0142\7!\2\2\u0142\u0143\7\'"+
		"\2\2\u0143\u0145\7\33\2\2\u0144\u013f\3\2\2\2\u0144\u0145\3\2\2\2\u0145"+
		"+\3\2\2\2\65/\638=KOUXfm\u0084\u0088\u008c\u0090\u0093\u0097\u009a\u009e"+
		"\u00a1\u00a5\u00a8\u00ac\u00af\u00b3\u00b6\u00ba\u00bd\u00c1\u00c4\u00c8"+
		"\u00cb\u00cf\u00d2\u00d6\u00d9\u00dd\u00e3\u00e5\u00f8\u00ff\u0102\u0107"+
		"\u010c\u0117\u011a\u0121\u0128\u012f\u0136\u013d\u0144";
	public static final ATN _ATN =
		new ATNDeserializer().deserialize(_serializedATN.toCharArray());
	static {
		_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
		for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
			_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
		}
	}
}